package com.solr.self.search;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;

/**
 * 
 * <Solrj操作类>
 * <功能详细描述>
 * 
 * @author  huanglizhi
 * @version  [版本号, 2012-7-4]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
public class SolrjOperator {

	/**
	 * <分词后组装查询语句进行查询>
	 * <功能详细描述>
	 * @param sbpo
	 * @param startIndex
	 * @param pageSize
	 * @return [参数说明]
	 * 
	 * @return DataGrid<List<SolrDocument>> [返回类型说明]
	 * @exception throws [违例类型] [违例说明]
	 * @see [类、类#方法、类#成员]
	 */
	public static DataGrid<List<SolrDocument>> getResultDataForJson(SolrSearchBasePO sbpo){
		// 建立搜索条件[1、方便查看调试；2、更方便设置权重；3、更容易扩展(比如增加扩展词典等)；4、可根据拼接的查询语句日志进行数据分析]
        ArrayList<String> words = KeyAnalysisSupport.analyseSearchOper(sbpo);
        SolrjQuery solrjQuery = new DefaultSolrjQuery(); 
        
        List<SolrDocument> resultList = new ArrayList<SolrDocument>();
        DataGrid<SolrDocumentList> dataGrid = new DataGrid<SolrDocumentList>();
        DataGrid<List<SolrDocument>> resultDataGrid = new DataGrid<List<SolrDocument>>();
        // 总记录数
        int lngRowCount = 0;
        for (String word : words)
        {
        	dataGrid = solrjQuery.querySolrResult(word, sbpo);
        	if (dataGrid.getData() !=null && dataGrid.getData().size() > 0)
            {
                sbpo.setOffset(0);
                /** 第一个分词结果集大于5条的话只取第一个分词结果集前5条记录；如果小于5，取第一
                                                            分词结果集n条记录(n<5)+第二个分词结果集的前5-n条记录
                */
                for (int i = 0; sbpo.getLimit() - resultList.size() > 0 && i < dataGrid.getData().size(); i++)
                {
                	SolrDocument solrDocument =  dataGrid.getData().get(i);
                	resultList.add(solrDocument);
                }
            }
            else
            {
                sbpo.setOffset(sbpo.getOffset() - dataGrid.getTotalElements());
                if (sbpo.getOffset() < 0)
                    sbpo.setOffset(0);
            }
            // 总记录
            lngRowCount += dataGrid.getTotalElements();
		}
        resultDataGrid.setData(resultList);
        resultDataGrid.setTotalElements(lngRowCount);
        return resultDataGrid;
	}
	
	/**
	 * <分词后组装查询语句进行查询>
	 * <功能详细描述>
	 * @param sbpo
	 * @param startIndex
	 * @param pageSize
	 * @return [参数说明]
	 * 
	 * @return DataGrid<List<SolrDocument>> [返回类型说明]
	 * @exception throws [违例类型] [违例说明]
	 * @see [类、类#方法、类#成员]
	 */
	public static DataGrid<List<Map<String,Object>>> getResultDataForMap(SolrSearchBasePO sbpo){
		// 建立搜索条件[1、方便查看调试；2、更方便设置权重；3、更容易扩展(比如增加扩展词典等)；4、可根据拼接的查询语句日志进行数据分析]
        ArrayList<String> words = KeyAnalysisSupport.analyseSearchOper(sbpo);
        SolrjQuery solrjQuery = new DefaultSolrjQuery(); 
        
        List<Map<String,Object>> resultMapList = new ArrayList<Map<String,Object>>();
        DataGrid<List<Map<String,Object>>> resultDataGrid = new DataGrid<List<Map<String,Object>>>();
        // 总记录数
        int lngRowCount = 0;
        for (String word : words)
        {
        	resultDataGrid = solrjQuery.querySolrResultForMap(word, sbpo);
        	if (resultDataGrid.getData() !=null && resultDataGrid.getData().size() > 0)
            {
                sbpo.setOffset(0);
                /** 第一个分词结果集大于5条的话只取第一个分词结果集前5条记录；如果小于5，取第一
                                                            分词结果集n条记录(n<5)+第二个分词结果集的前5-n条记录
                */
                for (int i = 0; sbpo.getLimit() - resultMapList.size() > 0 && i < resultDataGrid.getData().size(); i++)
                {
                	Map<String,Object> mapData =  resultDataGrid.getData().get(i);
                	resultMapList.add(mapData);
                }
            }
            else
            {
                sbpo.setOffset(sbpo.getOffset() - resultDataGrid.getTotalElements());
                if (sbpo.getOffset() < 0)
                    sbpo.setOffset(0);
            }
            // 总记录
            lngRowCount += resultDataGrid.getTotalElements();
		}
        resultDataGrid.setData(resultMapList);
        resultDataGrid.setTotalElements(lngRowCount);
        return resultDataGrid;
	}
	
	/**
	 * <分词后组装查询语句进行查询>
	 * <功能详细描述>
	 * @param sbpo
	 * @param startIndex
	 * @param pageSize
	 * @return [参数说明]
	 * 
	 * @return DataGrid<List<SolrDocument>> [返回类型说明]
	 * @exception throws [违例类型] [违例说明]
	 * @see [类、类#方法、类#成员]
	 */
	public static <T> DataGrid<List<T>> getResultDataForBO(SolrSearchBasePO sbpo, Class<T> clazz){
		// 建立搜索条件[1、方便查看调试；2、更方便设置权重；3、更容易扩展(比如增加扩展词典等)；4、可根据拼接的查询语句日志进行数据分析]
        ArrayList<String> words = KeyAnalysisSupport.analyseSearchOper(sbpo);
        SolrjQuery solrjQuery = new DefaultSolrjQuery(); 
        
        List<T> resultBOList = new ArrayList<T>();
        DataGrid<List<T>> resultDataGrid = new DataGrid<List<T>>();
        // 总记录数
        int lngRowCount = 0;
        for (String word : words)
        {
        	System.out.println(word);
        	resultDataGrid = solrjQuery.querySolrResultForBO(word, sbpo, clazz);
        	if (resultDataGrid.getData() !=null && resultDataGrid.getData().size() > 0)
            {
                sbpo.setOffset(0);
                /** 第一个分词结果集大于5条的话只取第一个分词结果集前5条记录；如果小于5，取第一
                                                            分词结果集n条记录(n<5)+第二个分词结果集的前5-n条记录
                */
                for (int i = 0; sbpo.getLimit() - resultBOList.size() > 0 && i < resultDataGrid.getData().size(); i++)
                {
                	T obj =  resultDataGrid.getData().get(i);
                	resultBOList.add(obj);
                }
            }
            else
            {
                sbpo.setOffset(sbpo.getOffset() - resultDataGrid.getTotalElements());
                if (sbpo.getOffset() < 0)
                    sbpo.setOffset(0);
            }
            // 总记录
            lngRowCount += resultDataGrid.getTotalElements();
		}
        resultDataGrid.setData(resultBOList);
        resultDataGrid.setTotalElements(lngRowCount);
        return resultDataGrid;
	}
	
	/**
	 * <分词后组装查询语句进行查询>
	 * <功能详细描述>
	 * @param sbpo
	 * @param startIndex
	 * @param pageSize
	 * @return [参数说明]
	 * 
	 * @return DataGrid<List<SolrDocument>> [返回类型说明]
	 * @exception throws [违例类型] [违例说明]
	 * @see [类、类#方法、类#成员]
	 */
	public static Map<String, Map<String, Long>> queryResultDataForFacet(SolrSearchBasePO sbpo){
		// 建立搜索条件[1、方便查看调试；2、更方便设置权重；3、更容易扩展(比如增加扩展词典等)；4、可根据拼接的查询语句日志进行数据分析]
        String queryContent = KeyAnalysisSupport.analyseFacetSearchOper(sbpo);
        SolrjQuery solrjQuery = new DefaultSolrjQuery(); 
        Map<String, Map<String, Long>> facetCountMap = solrjQuery.querySolrResultForFacet(queryContent, sbpo);
        return facetCountMap;
	}
	
}
